home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 25 / CU Amiga Magazine's Super CD-ROM 25 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-08].iso / CUCD / Programming / GMS / GMSDev / Includes / clib / dpkernel_protos.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-12  |  10.9 KB  |  365 lines
  1. #ifndef  CLIB_DPKERNEL_PROTOS_H
  2. #define  CLIB_DPKERNEL_PROTOS_H
  3.  
  4. /*
  5. **  $VER: dpkernel_protos.h V1.0
  6. **
  7. **  C prototypes.
  8. **
  9. **  (C) Copyright 1996-1998 DreamWorld Productions.
  10. **      All Rights Reserved.
  11. */
  12.  
  13. #ifndef  DPKERNEL_H
  14. #include <dpkernel/dpkernel.h>
  15. #endif
  16.  
  17. #ifndef MODULES_DPKBASE_H
  18. #include <modules/dpkbase.h>
  19. #endif
  20.  
  21. #ifndef _USE_DPKBASE
  22.  
  23. void yyx0000(void);
  24. void TagInitTags(APTR,APTR);
  25.  
  26. ECODE  Activate(APTR Object);
  27. struct Event * AddSysEvent(APTR TagList);
  28. struct Event * AddSysEventTags(ULONG tag1Type, ...);
  29. struct SysObject * AddSysObject(WORD ClassID, WORD ObjectID, BYTE *Name, APTR TagList);
  30. struct SysObject * AddSysObjectTags(WORD ClassID, WORD ObjectID, BYTE *Name, ULONG tag1Type, ...);
  31. LONG   AddTrack(LONG Resource, LONG Data, APTR Routine);
  32. APTR   AllocMemBlock(LONG Size, LONG MemType);
  33. void   Armageddon(LONG Key);
  34. ECODE  AttemptExclusive(APTR Object, WORD Ticks);
  35. void   AutoStop(void);
  36. LONG   Awaken(struct DPKTask *);
  37. LONG   CallEventList(LONG ID, APTR Arg1, LONG Arg2);
  38. ECODE  CheckAction(APTR Object, LONG ActionTag);
  39. struct DPKTask * CheckExclusive(APTR Object);
  40. LONG   CheckInit(APTR Object);
  41. LONG   CheckLock(APTR Object);
  42. LONG   Clear(APTR Object);
  43. void   CloseDPK(void);
  44. LONG   Copy(APTR Source, APTR Destination);
  45. LONG   CopyStructure(APTR Source, APTR Destination);
  46. LONG   Deactivate(APTR Object);
  47. void   DeleteTrack(LONG Key);
  48. LONG   Detach(APTR Object1, APTR Object2);
  49. void   DPKForbid(void);
  50. void   DPKPermit(void);
  51. void   DPrintF(BYTE *Header, const BYTE *, ...);
  52. ECODE  Draw(APTR Object);
  53. ECODE  ErrCode(LONG ErrorCode);
  54. ECODE  Exclusive(APTR Object);
  55. LONG   FastRandom(LONG Range);
  56. struct DPKTask *   FindDPKTask(void);
  57. struct SysObject * FindSysObject(WORD ID, struct SysObject *);
  58. LONG   FingerOfDeath(struct DPKTask *);
  59. LONG   Flush(APTR Object);
  60. void   Free(APTR Object);
  61. void   FreeExclusive(APTR Object);
  62. void   FreeMemBlock(APTR MemBlock);
  63. APTR   Get(LONG ID);
  64. LONG   GetMemSize(APTR MemBlock);
  65. LONG   GetMemType(APTR MemBlock);
  66. BYTE * GetExtension(APTR Object);
  67. BYTE * GetFileType(APTR Object);
  68. struct ItemList * GetTypeList(WORD ClassID);
  69. void   Hide(APTR Object);
  70. APTR   Init(APTR Object, APTR Container);
  71. APTR   InitTags(APTR Container, ULONG tag1Type, ...);
  72. APTR   InitTagList(struct TagItem *, APTR Container);
  73. void   InitDestruct(void *DestructCode, APTR DestructStack);
  74. APTR   Load(APTR Source, WORD ID);
  75. APTR   LoadPrefs(struct DPKTask *, BYTE *Name);
  76. LONG   Lock(APTR Object);
  77. LONG   MoveToBack(APTR Object);
  78. LONG   MoveToFront(APTR Object);
  79. struct Module * OpenModule(LONG ID, BYTE *Name);
  80. ECODE  Query(APTR Object);
  81. LONG   Read(APTR Object, APTR Buffer, LONG Length);
  82. APTR   Realloc(APTR Memory, LONG NewSize);
  83. void   RemapKernel(APTR Functions);
  84. void   RemSysEvent(struct Event *);
  85. void   RemSysObject(struct SysObject *);
  86. ECODE  Rename(APTR Object, BYTE *Name);
  87. LONG   Reset(APTR Object);
  88. ECODE  SaveToFile(APTR Object, struct FileName *, BYTE *FileType);
  89. struct DPKTask * SearchForTask(BYTE *Name, struct DPKTask *);
  90. LONG   Seek(APTR Object, LONG Offset, WORD Position);
  91. void   SelfDestruct(void);
  92. ECODE  Show(APTR Object);
  93. LONG   SlowRandom(LONG Range);
  94. void   StepBack(void);
  95. LONG   Stream(APTR SrcObject, APTR DestObject, LONG Length);
  96. void   OldSwitch(void);
  97. LONG   TagInit(APTR Structure, APTR TagList);
  98. LONG   TotalMem(struct DPKTask *, LONG Flags);
  99. LONG   Unhook(APTR Object, APTR Chain);
  100. void   Unlock(APTR Object);
  101. void   WaitTime(WORD MicroSeconds);
  102. LONG   Write(APTR Object, APTR Buffer, LONG Length);
  103.  
  104. LONG   AllocObjectID(void);
  105. struct Reference * FindReference(LONG ClassID, struct Reference *Reference);
  106. struct SysObject * FindSysObjectName(BYTE *Name);
  107. APTR   GetByName(BYTE *Name);
  108. LONG   SetDebug(APTR DPrintF, APTR DebugMsg);
  109.  
  110. #else /*** Definition for inline library calls ***/
  111.  
  112. FNCALL ECODE Activate(APTR Object) {
  113.   return(DPKBase->Activate(Object));
  114. }
  115. FNCALL struct Event * AddSysEvent(APTR TagList) {
  116.   return(DPKBase->AddSysEvent(TagList));
  117. }
  118. FNCALL struct SysObject * AddSysObject(WORD ClassID, WORD ObjectID, BYTE *Name, APTR TagList) {
  119.   return(DPKBase->AddSysObject(ClassID, ObjectID, Name, TagList));
  120. }
  121. FNCALL LONG AddTrack(LONG Resource, LONG Data, APTR Routine) {
  122.   return(DPKBase->AddTrack(Resource, Data, Routine));
  123. }
  124. FNCALL APTR AllocMemBlock(LONG Size, LONG MemType) {
  125.   return(DPKBase->AllocMemBlock(Size, MemType));
  126. }
  127. FNCALL void Armageddon(LONG Key) {
  128.   DPKBase->Armageddon(Key);
  129. }
  130. FNCALL ECODE AttemptExclusive(APTR Object, WORD Ticks) {
  131.   return(DPKBase->AttemptExclusive(Object, Ticks));
  132. }
  133. FNCALL void AutoStop(void) {
  134.   DPKBase->AutoStop();
  135. }
  136. FNCALL LONG Awaken(struct DPKTask *Task) {
  137.   return(DPKBase->Awaken(Task));
  138. }
  139. FNCALL LONG CallEventList(LONG ID, APTR Arg1, LONG Arg2) {
  140.   return(DPKBase->CallEventList(ID, Arg1, Arg2));
  141. }
  142. FNCALL ECODE CheckAction(APTR Object, LONG ActionTag) {
  143.   return(DPKBase->CheckAction(Object, ActionTag));
  144. }
  145. FNCALL struct DPKTask * CheckExclusive(APTR Object) {
  146.   return(DPKBase->CheckExclusive(Object));
  147. }
  148. FNCALL LONG CheckInit(APTR Object) {
  149.   return(DPKBase->CheckInit(Object));
  150. }
  151. FNCALL LONG CheckLock(APTR Object) {
  152.   return(DPKBase->CheckLock(Object));
  153. }
  154. FNCALL LONG Clear(APTR Object) {
  155.   return(DPKBase->Clear(Object));
  156. }
  157. FNCALL void CloseDPK(void) {
  158.   DPKBase->CloseDPK();
  159. }
  160. FNCALL LONG Copy(APTR Source, APTR Destination) {
  161.   return(DPKBase->Copy(Source, Destination));
  162. }
  163. FNCALL LONG CopyStructure(APTR Source, APTR Destination) {
  164.   return(DPKBase->CopyStructure(Source, Destination));
  165. }
  166. FNCALL LONG Deactivate(APTR Object) {
  167.   return(DPKBase->Deactivate(Object));
  168. }
  169. FNCALL void DeleteTrack(LONG Key) {
  170.   DPKBase->DeleteTrack(Key);
  171. }
  172. FNCALL LONG Detach(APTR Object1, APTR Object2) {
  173.   return(DPKBase->Detach(Object1, Object2));
  174. }
  175. FNCALL void DPKForbid(void) {
  176.   DPKBase->DPKForbid();
  177. }
  178. FNCALL void DPKPermit(void) {
  179.   DPKBase->DPKPermit();
  180. }
  181. FNCALL ECODE Draw(APTR Object) {
  182.   return(DPKBase->Draw(Object));
  183. }
  184. FNCALL ECODE ErrCode(LONG ErrorCode) {
  185.   return(DPKBase->ErrCode(ErrorCode));
  186. }
  187. FNCALL ECODE Exclusive(APTR Object) {
  188.   return(DPKBase->Exclusive(Object));
  189. }
  190. FNCALL LONG FastRandom(LONG Range) {
  191.   return(DPKBase->FastRandom(Range));
  192. }
  193. FNCALL struct DPKTask * FindDPKTask(void) {
  194.   return(DPKBase->FindDPKTask());
  195. }
  196. FNCALL struct SysObject * FindSysObject(WORD ID, struct SysObject *SysObject) {
  197.   return(DPKBase->FindSysObject(ID, SysObject));
  198. }
  199. FNCALL LONG FingerOfDeath(struct DPKTask *Task) {
  200.   return(DPKBase->FingerOfDeath(Task));
  201. }
  202. FNCALL LONG Flush(APTR Object) {
  203.   return(DPKBase->Flush(Object));
  204. }
  205. FNCALL void Free(APTR Object) {
  206.   return(DPKBase->Free(Object));
  207. }
  208. FNCALL void FreeExclusive(APTR Object) {
  209.   DPKBase->FreeExclusive(Object);
  210. }
  211. FNCALL void FreeMemBlock(APTR MemBlock) {
  212.   DPKBase->FreeMemBlock(MemBlock);
  213. }
  214. FNCALL APTR Get(LONG ID) {
  215.   return(DPKBase->Get(ID));
  216. }
  217. FNCALL LONG GetMemSize(APTR MemBlock) {
  218.   return(DPKBase->GetMemSize(MemBlock));
  219. }
  220. FNCALL LONG GetMemType(APTR MemBlock) {
  221.   return(DPKBase->GetMemType(MemBlock));
  222. }
  223. FNCALL BYTE * GetExtension(APTR Object) {
  224.   return(DPKBase->GetExtension(Object));
  225. }
  226. FNCALL BYTE * GetFileType(APTR Object) {
  227.   return(DPKBase->GetFileType(Object));
  228. }
  229. FNCALL struct ItemList * GetTypeList(WORD ClassID) {
  230.   return(DPKBase->GetTypeList(ClassID));
  231. }
  232. FNCALL void Hide(APTR Object) {
  233.   DPKBase->Hide(Object);
  234. }
  235. FNCALL APTR Init(APTR Object, APTR Container) {
  236.   return(DPKBase->Init(Object, Container));
  237. }
  238. FNCALL APTR InitTagList(APTR Object, APTR Container) {
  239.   return(DPKBase->Init(Object, Container));
  240. }
  241. FNCALL void InitDestruct(void *DestructCode, APTR DestructStack) {
  242.   DPKBase->InitDestruct(DestructCode, DestructStack);
  243. }
  244. FNCALL APTR Load(APTR Source, WORD ID) {
  245.   return(DPKBase->Load(Source, ID));
  246. }
  247. FNCALL APTR LoadPrefs(struct DPKTask *Task, BYTE *Name) {
  248.   return(DPKBase->LoadPrefs(Task, Name));
  249. }
  250. FNCALL LONG Lock(APTR Object) {
  251.   return(DPKBase->Lock(Object));
  252. }
  253. FNCALL LONG MoveToBack(APTR Object) {
  254.   return(DPKBase->MoveToBack(Object));
  255. }
  256. FNCALL LONG MoveToFront(APTR Object) {
  257.   return(DPKBase->MoveToFront(Object));
  258. }
  259. FNCALL struct Module * OpenModule(LONG ID, BYTE *Name) {
  260.   return(DPKBase->OpenModule(ID, Name));
  261. }
  262. FNCALL ECODE Query(APTR Object) {
  263.   return(DPKBase->Query(Object));
  264. }
  265. FNCALL LONG Read(APTR Object, APTR Buffer, LONG Length) {
  266.   return(DPKBase->Read(Object, Buffer, Length));
  267. }
  268. FNCALL APTR Realloc(APTR Memory, LONG NewSize) {
  269.   return(DPKBase->Realloc(Memory, NewSize));
  270. }
  271. FNCALL void RemapKernel(APTR Functions) {
  272.   DPKBase->RemapKernel(Functions);
  273. }
  274. FNCALL void RemSysEvent(struct Event *Event) {
  275.   DPKBase->RemSysEvent(Event);
  276. }
  277. FNCALL void RemSysObject(struct SysObject *SysObject) {
  278.   DPKBase->RemSysObject(SysObject);
  279. }
  280. FNCALL ECODE Rename(APTR Object, BYTE *Name) {
  281.   return(DPKBase->Rename(Object, Name));
  282. }
  283. FNCALL LONG Reset(APTR Object) {
  284.   return(DPKBase->Reset(Object));
  285. }
  286. FNCALL ECODE SaveToFile(APTR Object, struct FileName *FileName, BYTE *FileType) {
  287.   return(DPKBase->SaveToFile(Object, FileName, FileType));
  288. }
  289. FNCALL struct DPKTask * SearchForTask(BYTE *Name, struct DPKTask *Task) {
  290.   return(DPKBase->SearchForTask(Name, Task));
  291. }
  292. FNCALL LONG Seek(APTR Object, LONG Offset, WORD Position) {
  293.   return(DPKBase->Seek(Object, Offset, Position));
  294. }
  295. FNCALL void SelfDestruct(void) {
  296.   DPKBase->SelfDestruct();
  297. }
  298. FNCALL ECODE Show(APTR Object) {
  299.   return(DPKBase->Show(Object));
  300. }
  301. FNCALL LONG SlowRandom(LONG Range) {
  302.   return(DPKBase->SlowRandom(Range));
  303. }
  304. FNCALL void StepBack(void) {
  305.   DPKBase->StepBack();
  306. }
  307. FNCALL LONG Stream(APTR SrcObject, APTR DestObject, LONG Length) {
  308.   return(DPKBase->Stream(SrcObject, DestObject, Length));
  309. }
  310. FNCALL void OldSwitch(void) {
  311.   DPKBase->OldSwitch();
  312. }
  313. FNCALL LONG TagInit(APTR Structure, APTR TagList) {
  314.   return(DPKBase->TagInit(Structure, TagList));
  315. }
  316. FNCALL LONG TotalMem(struct DPKTask *Task, LONG Flags) {
  317.   return(DPKBase->TotalMem(Task, Flags));
  318. }
  319. FNCALL LONG Unhook(APTR Object, APTR Chain) {
  320.   return(DPKBase->Unhook(Object, Chain));
  321. }
  322. FNCALL void Unlock(APTR Object) {
  323.   DPKBase->Unlock(Object);
  324. }
  325. FNCALL void WaitTime(WORD MicroSeconds) {
  326.   DPKBase->WaitTime(MicroSeconds);
  327. }
  328. FNCALL LONG Write(APTR Object, APTR Buffer, LONG Length) {
  329.   return(DPKBase->Write(Object, Buffer, Length));
  330. }
  331. FNCALL LONG AllocObjectID(void) {
  332.   return(DPKBase->AllocObjectID());
  333. }
  334. FNCALL struct Reference * FindReference(LONG ClassID, struct Reference *Reference) {
  335.   return(DPKBase->FindReference(ClassID, Reference));
  336. }
  337. FNCALL struct SysObject * FindSysObjectName(BYTE *Name) {
  338.   return(DPKBase->FindSysObjectName(Name));
  339. }
  340. FNCALL APTR GetByName(BYTE *Name) {
  341.   return(DPKBase->GetByName(Name));
  342. }
  343. FNCALL LONG SetDebug(APTR DPrintF, APTR DebugMsg) {
  344.   return(DPKBase->SetDebug(DPrintF, DebugMsg));
  345. }
  346.  
  347. /*** Non-inline calls (necessary for tags) ***/
  348.  
  349. APTR InitTags(APTR Container, ULONG tag1Type, ...) {
  350.   return(DPKBase->Init(Container, &tag1Type));
  351. }
  352. void DPrintF(BYTE *Header, ULONG String, ...) {
  353.   DPKBase->DPrintF(Header, (BYTE *)&String);
  354. }
  355. struct SysObject * AddSysObjectTags(WORD ClassID, WORD ObjectID, BYTE *Name, ULONG tag1Type, ...) {
  356.   return(DPKBase->AddSysObject(ClassID, ObjectID, Name, &tag1Type));
  357. }
  358. struct Event * AddSysEventTags(ULONG tag1Type, ...) {
  359.   return(DPKBase->AddSysEvent(&tag1Type));
  360. }
  361.  
  362. #endif /* _USE_DPKBASE */
  363.  
  364. #endif /* CLIB_DPKERNEL_PROTOS_H */
  365.